home *** CD-ROM | disk | FTP | other *** search
/ MacHome 2001 June / MacHome Magazine Demo Disc June 2001.iso / Stuff / Software / Network / Snak / Snak 4.5.4 PPC / Scripts / pp-dcc.irc < prev    next >
Encoding:
Text File  |  2000-10-31  |  26.6 KB  |  913 lines  |  [TEXT/R*ch]
  1. # ########################################################################## #
  2. #                      PurePak - The sequel to TextBox                       #
  3. #                          A -+ TEXT +- production                           #
  4. # ########################################################################## #
  5. # Author: Crypt Keeper [ckeeper@axiom.access.one.net] (CKeeper on IRC)
  6. # Version 2.07
  7. #
  8. # This script requires at least ircII2.2.9 (Unix) or a fully ircII compatible
  9. # client.  It has only been tested under Unix with ircII2.2.9 and ircII2.8.2.
  10. #
  11. # If you edit this file, you must edit it with a Unix text editor or use
  12. # utilities like dos2unix/unix2dos to convert it to DOS to edit and then
  13. # back to Unix.  If it is edited in a DOS text editor it will be corrupted.
  14. #
  15. # PurePak version 2.07 IRC script
  16. # Copyright (C) 1995
  17. #
  18. # This program is free software; you can redistribute it and/or modify
  19. # it under the terms of the GNU General Public License as published by
  20. # the Free Software Foundation; either version 1, or (at your option)
  21. # any later version.
  22. #
  23. # This program is distributed in the hope that it will be useful,
  24. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  25. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26. # GNU General Public License for more details.
  27. #
  28. # You should have received a copy of the GNU General Public License
  29. # along with this program; if not, write to the Free Software
  30. # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31. # ########################################################################## #
  32.  
  33. EVAL ^if (!(PPVERS)) {/echo *** This is not a stand-alone script, it must be loaded after purepak.irc;//exit}
  34.  
  35. # DCC fileserver/manager script
  36. @ PP.DCC = 1
  37.  
  38. # ----------------------------------------------------------------------------
  39. # DCC alias
  40. # ----------------------------------------------------------------------------
  41.  
  42. alias xdcc {/dcc $*}
  43. alias dcc {
  44.     if ([$0])
  45.     {
  46.         if (match($0 SEND GET RAW TALK CHAT OFFER DOFFER LIST PLIST NOTICE DLDIR FRIENDS AUTOGET LOAD SAVE CLOSE LIMIT RENAME TMSG NOTE SERVER TIMEOUT QUEUEING PUBLIST AUTOCHAT))
  47.         {
  48.             if (match($0 RAW TALK RENAME TMSG SEND CHAT)) {//dcc $*}
  49.             if (match($0 CLOSE OFFER DOFFER LIST PLIST NOTICE DLDIR AUTOGET FRIENDS LOAD SAVE GET LIMIT NOTE SERVER TIMEOUT QUEUEING PUBLIST AUTOCHAT)) {/dcc.ucmd.$0 $1-}
  50.         } {/echo *** Unrecognized DCC command, type /pphelp dcc}
  51.     }
  52.     {
  53.         if (!PP.EPIC)
  54.         {
  55.             dcc.updatestatus
  56.             @ GDCCS = 0
  57.             if (DCC.GETS)
  58.             {
  59.                 @ GDCCS = 1
  60.                 echo *** Incoming files: From      Status      Read       Filename
  61.                 foreach DCC.GETS AA {
  62.                     EVAL ^foreach DCC.GETS.$AA XY {
  63.                         @ NK = decode($AA)
  64.                         if (word(0 $DCC.GETS[$AA][$XY]) == [W]) {@ ST = [Waiting]} {@ ST = [In Progress]}
  65.                         @ BT = word(2 $DCC.GETS[$AA][$XY])
  66.                         echo ***                 $[9]NK $[11]ST $[10]BT $right(24 $decode($XY))
  67.                     }
  68.                 }
  69.             }
  70.             if (DCC.SENDS)
  71.             {
  72.                 @ GDCCS = 1
  73.                 echo *** Outgoing files: To        Status      Written    Filename
  74.                 foreach DCC.SENDS AA {
  75.                     EVAL ^foreach DCC.SENDS.$AA XY {
  76.                         @ NK = decode($AA)
  77.                         if (word(0 $DCC.SENDS[$AA][$XY]) == [W]) {@ ST = [Waiting]} {@ ST = [In Progress]}
  78.                         @ BT = word(1 $DCC.SENDS[$AA][$XY])
  79.                         echo ***                 $[9]NK $[11]ST $[10]BT $right(24 $decode($XY))
  80.                     }
  81.                 }
  82.             }
  83.             if (DCC.CHATS)
  84.             {
  85.                 foreach DCC.CHATS AA {
  86.                     if (word(0 $DCC.CHATS[$AA]) == [W]) {/echo *** DCC CHAT request to $decode($AA) not established (waiting)}
  87.                     if (word(0 $DCC.CHATS[$AA]) == [O]) {/echo *** DCC CHAT offered from $decode($AA)}
  88.                     if (word(0 $DCC.CHATS[$AA]) == [A]) {/echo *** DCC CHAT active to $decode($AA)}
  89.                 }
  90.                 @ GDCCS = 1
  91.             }
  92.             if (GDCCS) {^assign -XY}
  93.             {/echo *** No active DCC CHAT, SEND, or GET connections}
  94.             ^assign -GDCCS
  95.         } {//dcc}
  96.     }
  97. }
  98.  
  99. EVAL ^if (!PP.SET.DCCDLDIR) {@ PP.SET.DCCDLDIR = [.]}
  100. EVAL ^if (!PP.SET.DCCAUTOGET) {@ PP.SET.DCCAUTOGET = [OFF]}
  101. EVAL ^if (!PP.SET.DCCFLAUTOGET) {@ PP.SET.DCCFLAUTOGET = [ON]}
  102. EVAL ^if (!PP.SET.DCCLIMIT) {@ PP.SET.DCCLIMIT = [-1]}
  103. EVAL ^if (!PP.SET.DCCSERVER) {@ PP.SET.DCCSERVER = [ON]}
  104. EVAL ^if (!PP.SET.DCCTIMEOUT) {@ PP.SET.DCCTIMEOUT = 90}
  105. EVAL ^if (!PP.SET.DCCPUBLIST) {@ PP.SET.DCCPUBLIST = [ON]}
  106. EVAL ^if (!PP.SET.DCCQUEUEING) {@ PP.SET.DCCQUEUEING = [ON]}
  107. EVAL ^if (!PP.SET.DCCAUTOCHAT) {@ PP.SET.DCCAUTOCHAT = [OFF]}
  108.  
  109. # ----------------------------------------------------------------------------
  110. # /dcc functions
  111. # ----------------------------------------------------------------------------
  112.  
  113. # /dcc autochat
  114. alias dcc.ucmd.autochat {
  115.     if (match($0 ON OFF)) {@ PP.SET.DCCAUTOCHAT = toupper($0)}
  116.     echo *** Auto accept DCC CHAT requests is now ${PP.SET.DCCAUTOCHAT}
  117. }
  118. # /dcc queueing
  119. alias dcc.ucmd.queueing {
  120.     if (match($0 ON OFF)) {@ PP.SET.DCCQUEUEING = toupper($0)}
  121.     echo *** Queueing of send requests if all slots are full is now ${PP.SET.DCCQUEUEING}
  122. }
  123. # /dcc server
  124. alias dcc.ucmd.server {
  125.     if (match($0 ON OFF)) {@ PP.SET.DCCSERVER = toupper($0)}
  126.     echo *** DCC server is now ${PP.SET.DCCSERVER}
  127. }
  128. # /dcc publist
  129. alias dcc.ucmd.publist {
  130.     if (match($0 ON OFF)) {@ PP.SET.DCCPUBLIST = toupper($0)}
  131.     echo *** Allow public CTCP XDCC LISTs is now ${PP.SET.DCCPUBLIST}
  132. }
  133. # /dcc note
  134. alias dcc.ucmd.note {
  135.     if ([$0]) {^if ([$0] != [-]) {@ DCC.NOTE = [$*]} {^assign -DCC.NOTE}}
  136.     if (DCC.NOTE) {/echo *** DCC offer list note: $DCC.NOTE} {/echo *** No DCC offer list note set}
  137. }
  138. # /dcc notice
  139. # Snak adaptation 1.4. Now only sends to the current channel - not all your channels
  140. # And don't make it reverse video.
  141. # Change wording to match the ircle fserv more closely
  142. alias dcc.ucmd.notice {
  143.     if (C)
  144.     {
  145.         if (dcc.havepacks()){
  146.             
  147.             if ($dcc.havepacks() == 1) {
  148.                 if ([$PP.SET.DCCLIMIT] != -1) {
  149.                     EVAL @ SEND_MSG = [** 1 pack ** ${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]
  150.                 }{EVAL @ SEND_MSG = [** 1 pack ** slots available]}
  151.             } { 
  152.             if ([$PP.SET.DCCLIMIT] != -1) {
  153.                     EVAL @ SEND_MSG = [** $dcc.havepacks() packs ** ${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]
  154.                 }{EVAL @ SEND_MSG = [** $dcc.havepacks() packs ** slots available]}
  155.             }
  156.             
  157.             ^pp.listmsg PRIVMSG $C
  158.             echo $SEND_MSG
  159.             
  160.             EVAL @ SEND_MSG = [** To request a file type "/msg $N xdcc send #n"]
  161.             ^pp.listmsg PRIVMSG $C
  162.             echo $SEND_MSG
  163.  
  164.             dcc.dolist 1 ^quote $0 $1 
  165.             dcc.dolist 1 ^echo 
  166.  
  167.  
  168.     #        ^pp.listmsg PRIVMSG $mychannels()
  169.     #        ^pp.listmsg PRIVMSG $C
  170.             ^assign -SEND_MSG
  171.         } {/echo *** You aren't offering any packs}
  172.         
  173.     } {/echo *** You aren't on any channels}
  174. }
  175. # /dcc offer
  176. # Snak adaptation 1.4. Modified to handle a list of file paths
  177. # Mac file paths can contain spaces, so input -files return a list that is separated with tabs
  178. # in another way. Use "listitem" to split it instead of "word"
  179. alias dcc.ucmd.offer {
  180.     ^input -files "Choose file(s) to offer: " if (1) {
  181.         if ([$0])
  182.         {
  183.             @ IDX = 0
  184.             while (listitem($IDX $*))
  185.             {
  186.                 if (fileexists($listitem($IDX $*))) {@ DCCFILS = DCCFILS##[$listitem($IDX $*) ]}
  187.                 {/echo *** File $listitem($IDX $*) does not exist or you have no permission to access}
  188.                 @ IDX = IDX + 1
  189.             }
  190.             if (DCCFILS)
  191.             {
  192.                 ^input "Enter a description for this pack: " if (1) {
  193.                     if ([$0])
  194.                     {
  195.                         @ IDX = 1
  196.                         while (DCCPACKS.FILES[$IDX]) {@ IDX = IDX + 1}
  197.                         @ DCCPACKS.FILES[$IDX] = DCCFILS
  198.                         @ DCCPACKS.DESC[$IDX] = [$*]
  199.                         @ DCCPACKS.STATS[$IDX] = [$W 0]
  200.                         echo *** Pack #$IDX added with files: ${DCCFILS}
  201.                         ^assign -IDX
  202.                         ^assign -DCCFILS
  203.                     }
  204.                     {
  205.                         ^assign -IDX
  206.                         ^assign -DCCFILS
  207.                         echo *** You must enter a description
  208.                     }
  209.                 }
  210.             }
  211.             {
  212.                 ^assign -IDX
  213.                 echo *** No files in pack!
  214.             }
  215.         } {/echo *** No files in pack!}
  216.     }
  217. }
  218. # /dcc doffer
  219. # snak adaptation 1.5 use listitem
  220. alias dcc.ucmd.doffer {
  221.     ^input "Enter pack number(s) to remove: " if (1) {
  222.         if ([$0])
  223.         {
  224.             @ AA = 0
  225.             while (word($AA $*))
  226.             {
  227.                 if (DCCPACKS.FILES[$listitem($AA $*)])
  228.                 {
  229.                     ^assign -DCCPACKS.FILES[$listitem($AA $*)]
  230.                     ^assign -DCCPACKS.DESC[$word($AA $*)]
  231.                     ^assign -DCCPACKS.STATS[$word($AA $*)]
  232.                     @ CTR = word($AA $*) + 1
  233.                     while (DCCPACKS.FILES[$CTR])
  234.                     {
  235.                         @ DCCPACKS.FILES[${CTR-1}] = DCCPACKS.FILES[$CTR]
  236.                         @ DCCPACKS.DESC[${CTR-1}] = DCCPACKS.DESC[$CTR]
  237.                         @ DCCPACKS.STATS[${CTR-1}] = DCCPACKS.STATS[$CTR]
  238.                         if (!(DCCPACKS.FILES[${CTR+1}]))
  239.                         {
  240.                             ^assign -DCCPACKS.FILES[$CTR]
  241.                             ^assign -DCCPACKS.DESC[$CTR]
  242.                             ^assign -DCCPACKS.STATS[$CTR]
  243.                         }
  244.                         @ CTR = CTR + 1
  245.                     }
  246.                     echo *** Pack #$word($AA $*) removed
  247.                 } {/echo *** There is no pack #$word($AA $*)}
  248.                 @ AA = AA + 1
  249.             }
  250.             ^assign -CTR
  251.         }
  252.     }
  253. }
  254. # /dcc list
  255. alias dcc.ucmd.list {
  256.     if (dcc.havepacks())
  257.     {
  258.         if (PP.SET.DCCLIMIT > 0) {/echo *** Files offered: [${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]}
  259.         {/echo *** Files offered:}
  260.         dcc.dolist 1 echo ***
  261.     } {/echo *** You have no files offered}
  262. }
  263. # /dcc save
  264. # Snak adaptation 1.4. Save package file in "home" directory, which for Snak is the scripts directory
  265. # Snak adaptation 1.5 use listitem
  266. #                      don't test to see if it is a full path, and don't prepend the stats
  267. #                       the addpack function can't deal with it - it is a bug in purepak 
  268. alias dcc.ucmd.save {
  269.     if ([$0])
  270.     {
  271.         @ LF = [${HOME}/$0]
  272.         exec -name rm $PP.SET.RMCMD ${HOME}/$0
  273.         wait -CMD %rm if (1) {
  274.             if (PP.EPIC)
  275.             {
  276.                 @ FHANDLE = open($LF w)
  277.                 if (FHANDLE > 0) {/EVAL ^assign WC /write $FHANDLE}
  278.                 {/echo *** Could not open $LF}
  279.             }
  280.             {
  281.                 ^window new
  282.                 ^window hold_mode off
  283.                 ^window name WRITEDCC
  284.                 ^window logfile $LF
  285.                 ^window log on
  286.                 @ WC = [/xecho -WINDOW WRITEDCC]
  287.             }
  288.             $WC # PurePak DCC module offer file, written $stime($time())
  289.             foreach DCCPACKS.FILES AA {
  290.                 @ CT = 0
  291.                 @ DFILES = []
  292.                 while (listitem($CT $DCCPACKS.FILES[$AA]))
  293.                 {
  294. #                    if (match(/* $listitem($CT $DCCPACKS.FILES[$AA]))) 
  295. #                    {
  296.                     @ DFILES = DFILES##[$listitem($CT $DCCPACKS.FILES[$AA]) ]
  297. #                    }
  298. #                    {
  299. #                    @ DFILES = DFILES##[$word(0 $DCCPACKS.STATS[$AA])/$listitem($CT $DCCPACKS.FILES[$AA]) ]
  300. #                    }
  301.                     
  302.                     @ CT = CT + 1
  303.                 }
  304.                 $WC ^dcc.addpack $encode($DFILES) $encode($DCCPACKS.DESC[$AA])
  305.             }
  306.             ^assign -CT
  307.             ^assign -DFILES
  308.             if (DCC.NOTE) {$WC ^dcc.ucmd.note $DCC.NOTE}
  309.             if (PP.EPIC)
  310.             {
  311.                 comment $close($FHANDLE)
  312.                 ^assign -FHANDLE
  313.             }
  314.             {
  315.                 ^window log off
  316.                 ^window kill
  317.             }
  318.             echo *** Current pack data written to $LF
  319.             ^assign -LF
  320.             ^assign -WC
  321.         }
  322.     } {/dcc.ucmd.save purepak.dcc}
  323. }
  324. # /dcc load
  325. alias dcc.ucmd.load {^if ([$0]) {//load $0} {//load purepak.dcc}}
  326. # /dcc plist
  327. alias dcc.ucmd.plist {
  328.     if (dcc.havepacks())
  329.     {
  330.         say Files offered: Type /msg $N xdcc send #N to get pack #N
  331.         if (PP.SET.DCCLIMIT > 0) {/say [${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]}
  332.         dcc.dolist 0 say
  333.     } {/echo *** You have no files offered}
  334. }
  335. # /dcc dldir
  336. alias dcc.ucmd.dldir {
  337.     if ([$0])
  338.     {
  339.         @ PP.SET.DCCDLDIR = [$0]
  340.         echo *** DCC download directory is now $0
  341.     } {/echo *** DCC download directory is now ${PP.SET.DCCDLDIR}}
  342. }
  343. # /dcc limit
  344. alias dcc.ucmd.limit {
  345.     if ([$0])
  346.     {
  347.         if (([$0] == [NONE])||([$0] == [OFF])) {@ PP.SET.DCCLIMIT = [-1]}
  348.         {
  349.             if (!isalpha($0)) {@ PP.SET.DCCLIMIT = [$0]}
  350.             {/echo *** Must be a numerical value}
  351.         }
  352.     }
  353.     if (PP.SET.DCCLIMIT == [-1]) {/echo *** DCC autosend file limit is now UNLIMITED}
  354.     {/echo *** DCC autosend file limit is now ${PP.SET.DCCLIMIT}}
  355. }
  356. # /dcc limit
  357. alias dcc.ucmd.timeout {
  358.     if ([$0])
  359.     {
  360.         if (([$0] == [NONE])||([$0] == [OFF])) {@ PP.SET.DCCTIMEOUT = [-1]}
  361.         {
  362.             if (!isalpha($0)) {@ PP.SET.DCCTIMEOUT = [$0]}
  363.             {/echo *** Must be a numerical value}
  364.         }
  365.     }
  366.     if (PP.SET.DCCTIMEOUT == [-1]) {/echo *** DCC autosend timeout is now UNLIMITED}
  367.     {/echo *** DCC autosend timeout is now ${PP.SET.DCCTIMEOUT}}
  368. }
  369. # /dcc autoget
  370. alias dcc.ucmd.autoget {
  371.     if (match($0 ON OFF)) {@ PP.SET.DCCAUTOGET = toupper($0)}
  372.     echo *** DCC autoget is now ${PP.SET.DCCAUTOGET}
  373. }
  374. # /dcc friends
  375. alias dcc.ucmd.friends {
  376.     if (match($0 ON OFF)) {@ PP.SET.DCCFLAUTOGET = toupper($0)}
  377.     echo *** DCC autoget from people in friends list is now ${PP.SET.DCCFLAUTOGET}
  378. }
  379. # /dcc get
  380. alias dcc.ucmd.get {
  381.     if ([$0])
  382.     {
  383.         if ([$1])
  384.         {
  385.             @ AA = 1
  386.             ^on ^window "% *No file offered in SEND*" {@ AA = 0}
  387.             //dcc get $0 $1
  388.             if (!AA) {/echo *** File $1 not offered by $0}
  389.         }
  390.         {
  391.             if ([$0])
  392.             {
  393.                 dcc.updatestatus
  394.                 @ FL = 0
  395.                 foreach DCC.GETS AA {
  396.                     if (toupper($decode($AA)) == toupper($0))
  397.                     {
  398.                         @ FL = 1
  399.                         EVAL foreach DCC.GETS.$AA XY {//dcc get $0 $decode($XY)}
  400.                         ^assign -XY
  401.                         echo *** Got all files offered by $0
  402.                     }
  403.                 }
  404.                 if (!FL) {/echo *** No files offered by $0}
  405.                 ^assign -FL
  406.             }
  407.             {
  408.                 dcc.updatestatus
  409.                 if (DCC.GETS)
  410.                 {
  411.                     foreach DCC.GETS AA {
  412.                         EVAL foreach DCC.GETS.$AA XY {//dcc get $decode($AA) $decode($XY)}
  413.                         ^assign -XY
  414.                     }
  415.                 } {/echo *** No files offered}
  416.             }
  417.         }
  418.     } {/echo *** /dcc get [<nick>] [<file>]}
  419. }
  420. # /dcc close
  421. alias dcc.ucmd.close {
  422.     if (match($0 RAW TALK CHAT RAW_LISTEN RAW_LIS)) {//dcc close $*}
  423.     {
  424.         @ AA = 0
  425.         if ([$0] == [SEND])
  426.         {
  427.             if ([$1])
  428.             {
  429.                 if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}
  430.                 if ([$2]) {//dcc close $*}
  431.                 {
  432.                     EVAL ^repeatcmd 30 //^dcc close send $1
  433.                     echo *** All DCC SENDs to $1 closed
  434.                 }
  435.             } {/echo *** /dcc close send <nick> [<file>]}
  436.             @ AA = 1
  437.         }
  438.         if ([$0] == [GET])
  439.         {
  440.             if ([$1])
  441.             {
  442.                 if ([$2]) {//dcc close $*}
  443.                 {
  444.                     EVAL ^repeatcmd 30 //^dcc close get $1
  445.                     echo *** All DCC GETs from $1 closed
  446.                 }
  447.             } {/echo *** /dcc close get <nick> [<file>]}
  448.             @ AA = 1
  449.         }
  450.         if (!AA) {/echo *** /dcc close <type> <nick> [<arguments>]}
  451.     }
  452. }
  453.  
  454. # ----------------------------------------------------------------------------
  455. # ON hooks and internal procedures
  456. # ----------------------------------------------------------------------------
  457.  
  458. on ^ctcp "% % DCC SEND % % % *" {
  459.     if (([$6] > 1024)&&([$6] < 65535))
  460.     {
  461.         if (!ischannel($1))
  462.         {
  463.             if ((!!(PP.SET.DCCDLDIR))&&(PP.SET.DCCDLDIR != [.])) {//dcc rename $0 $4 ${PP.SET.DCCDLDIR}/$4}
  464.             if (PP.SET.DCCAUTOGET == [ON])
  465.             {
  466.                 echo *** Autogetting DCC SEND $4 from $0
  467.                 ^timer 2 //dcc get $0 $4
  468.             }
  469.             {
  470.                 if (PP.SET.DCCFLAUTOGET == [ON])
  471.                 {
  472.                     foreach PP.FRIENDS AA {@ FNDS = FNDS##[ $PP.FRIENDS[$AA]]}
  473.                     if (rmatch($0!$USERHOST() $FNDS))
  474.                     {
  475.                         echo *** Autogetting DCC SEND $4 from $0\; $0 is on your friends list
  476.                         //dcc get $0 $4
  477.                     }
  478.                     ^assign -FNDS
  479.                 }
  480.             }
  481.         } {/echo *** Strange: $0 sent a DCC SEND request adressed to channel $1}
  482.     }
  483.     {
  484.         ^timer 1 /echo *** DCC SEND request from $0 using priviledged port detected\; ignored (bomb?)
  485.         //dcc close get $0 $4
  486.     }
  487. }
  488. on ^ctcp "% % DCC CHAT % % *" {
  489.     if (([$6] < 1024)||([$6] > 65535))
  490.     {
  491.         ^timer 1 /echo *** DCC CHAT request from $0 using priviledged port detected\; ignored (bomb?)
  492.         //dcc close chat $0
  493.         //dcc close chat $0
  494.     }
  495.     {
  496.         if (PP.SET.DCCAUTOCHAT == [ON])
  497.         {
  498.             ^timer 1 /echo *** Autogetting DCC CHAT request from $0
  499.             //dcc chat $0
  500.         }
  501.         {
  502.             if (PP.SET.DCCFLAUTOGET == [ON])
  503.             {
  504.                 foreach PP.FRIENDS AA {@ FNDS = FNDS##[ $PP.FRIENDS[$AA]]}
  505.                 if (rmatch($0!$USERHOST() $FNDS))
  506.                 {
  507.                     ^timer 1 /echo *** Autogetting DCC CHAT request from $0\; $0 is on your friends list
  508.                     //dcc chat $0
  509.                 }
  510.                 ^assign -FNDS
  511.             }
  512.         }
  513.     }
  514. }
  515.  
  516. # We use a raw_irc for on msg to prevent a beep if BEEP_ON_MSG is set
  517. on ^raw_irc "% PRIVMSG % :XDCC *" {
  518.     if (!ischannel($2))
  519.     {
  520.         if (PP.SET.DCCSERVER == [ON]) {/dcc.msg $nickonly($0) $N $mid(${index(! $0)+1} 1000 $0) $4-}
  521.     }
  522.     {
  523.         if ([$2] == C) {/xecho -LEVEL PUBLIC <$nickonly($0)> $strip(: $3) $4-}
  524.         {/xecho -LEVEL PUBLIC <$nickonly($0):$2> $strip(: $3) $4-}
  525.     }
  526. }
  527. on ^ctcp "% % XDCC *" {^if (PP.SET.DCCSERVER == [ON]) {/dcc.msg $0 $1 $USERHOST() $3-}}
  528. alias dcc.msg {
  529.     if (right(10 $2) != LASTDCCER)
  530.     {
  531.         if (ischannel($1))
  532.         {
  533.             if (match($3 SEND LIST HELP VERSION LSPACK))
  534.             {
  535.                 if ([$3] == [LIST])
  536.                 {
  537.                     if (PP.SET.DCCPUBLIST == [ON])
  538.                     {
  539.                         if (dcc.havepacks()) {/dcc.msg $0 $N $2-}
  540.                     } {/echo *** $0 request for DCC LIST to everyone in $1 ignored}
  541.                 }
  542.                 {
  543.                     echo *** $0 request for DCC $toupper($3) to everyone in $1 ignored\; only LIST is allowed globally
  544.                     //^notice $0 Only DCC LISTs are allowed globally
  545.                 }
  546.             }
  547.             {
  548.                 echo *** Invalid DCC server command from $0 to $1
  549.                 //^notice $0 Unknown DCC server command\; type /msg $N XDCC HELP
  550.             }
  551.         }
  552.         {
  553.             if (match($3 SEND LIST HELP VERSION LSPACK)) {/dcc.mcmd.$3 $0 $2 $4-}
  554.             {
  555.                 echo *** Invalid DCC server command from $0
  556.                 //^notice $0 Unknown DCC server command\; type /msg $N XDCC HELP
  557.             }
  558.         }
  559.     }
  560.     if (!LASTDCCER) {^timer 3 ^assign -LASTDCCER}
  561.     @ LASTDCCER = right(10 $2)
  562. }
  563.  
  564. # Updates DCC status variables by capturing /dcc's output
  565. # Doesn't work on EPIC clients :P
  566. alias dcc.updatestatus {
  567.     ^on ^window "% Type*Nick*Status*Start*time*Sent*Read*Arguments*" {}
  568.     ^on ^window "% SEND *" {
  569.         if ([$3] == [Waiting]) {@ DCC.SENDS[$encode($2)][$encode($6)] = [W $4 $5]} {@ DCC.SENDS[$encode($2)][$encode($10)] = [A $8 $9]}
  570.         @ DCC.SENDS = 1
  571.     }
  572.     ^on ^window "% GET *" {
  573.         if ([$3] == [Offered]) {@ DCC.GETS[$encode($2)][$encode($6)] = [W $4 $5]} {@ DCC.GETS[$encode($2)][$encode($10)] = [A $8 $9]}
  574.         @ DCC.GETS = 1
  575.     }
  576.     ^on ^window "% RAW *" {}
  577.     ^on ^window "% CHAT *" {
  578.         if ([$3] == [Waiting]) {@ DCC.CHATS[$encode($2)] = [W $4 $5]}
  579.         {
  580.             if ([$3] == [Offered]) {@ DCC.CHATS[$encode($2)] = [O $4 $5]} {@ DCC.CHATS[$encode($2)] = [A $8 $9]}
  581.         }
  582.         @ DCC.CHATS = 1
  583.     }
  584.     ^on ^window "% RAW_LIS *raw_listen*" {}
  585.     ^on ^window "% TALK *" {}
  586.     foreach DCC.SENDS AA {/EVAL ^foreach DCC.SENDS.$AA BB {^assign -DCC.SENDS[$AA][$BB]}}
  587.     foreach DCC.GETS AA {/EVAL ^foreach DCC.GETS.$AA BB {^assign -DCC.GETS[$AA][$BB]}}
  588.     foreach DCC.CHATS AA {^assign -DCC.CHATS[$AA]}
  589.     ^assign -DCC.SENDS
  590.     ^assign -DCC.GETS
  591.     ^assign -DCC.CHATS
  592.     ^assign -BB
  593.     //dcc
  594.     ^on window - "% TALK *"
  595.     ^on window - "% CHAT *"
  596.     ^on window - "% RAW *"
  597.     ^on window - "% GET *"
  598.     ^on window - "% RAW_LIS *raw_listen*"
  599.     ^on window - "% Type*Nick*Status*Start*time*Sent*Read*Arguments*"
  600.     ^on window - "% SEND *"
  601. }
  602.  
  603. # Executed when a saved pack file loads
  604. # snak adaptation 1.5 use listitem
  605. alias dcc.addpack {
  606.     @ FILZ = decode($0)
  607.         
  608.     @ AA = 0
  609.     while (listitem($AA $FILZ))
  610.     {
  611.     
  612.     echo there
  613.         if (!fileexists($listitem($AA $FILZ)))
  614.         {
  615.             ^delword $listitem($AA $FILZ) $FILZ
  616.             echo *** LOAD: file $listitem($AA $FILZ) does not exist, removed from pack
  617.             @ FILZ = NLIST
  618.             ^assign -NLIST
  619.         }
  620.         @ AA = AA + 1
  621.     }
  622.     
  623.     if ([$#FILZ] > 0)
  624.     {
  625.         @ IDX = 1
  626.         while (DCCPACKS.FILES[$IDX]) {@ IDX = IDX + 1}
  627.         @ DCCPACKS.FILES[$IDX] = FILZ
  628.         @ DCCPACKS.DESC[$IDX] = decode($1)
  629.         @ DCCPACKS.STATS[$IDX] = [$W 0]
  630.         echo *** Pack #$IDX loaded with files: $FILZ
  631.         echo ***   - Description: $decode($1)
  632.         ^assign -IDX
  633.     } {/echo *** Pack not restored: no files}
  634.     ^assign -FILZ
  635. }
  636.  
  637. # Executed whenever the user changes nicks with /nick
  638. alias dcc.onnick {
  639.     if ([$0])
  640.     {
  641.         @ DCC.MYNICK = [$0]
  642.         EVAL ^on raw_irc - "${N}!% PRIVMSG $N :DCC SEND **"
  643.         EVAL ^on ^raw_irc "$0!% PRIVMSG $0 :DCC SEND **" {
  644.             @ DCC.SINT.FNAME = [$5]
  645.             @ DCC.SINT.FSIZE = strip( $8)
  646.             //^dcc close send $N
  647.             //^dcc close get $N
  648.             $DCC.ONREPCMD
  649.         }
  650.     }
  651. }
  652. EVAL ^on ^raw_irc "${N}!% PRIVMSG $N :DCC SEND **" {
  653.     @ DCC.SINT.FNAME = [$5]
  654.     @ DCC.SINT.FSIZE = strip( $8)
  655.     //^dcc close send $N
  656.     //^dcc close get $N
  657.     $DCC.ONREPCMD
  658. }
  659. @ DCC.ONREPCMD = [/dcc.norepcmd]
  660. alias dcc.norepcmd {
  661.     @ DCC.FSIZES[$encode($tolower($DCC.SINT.FNAME))] = DCC.SINT.FSIZE
  662.     ^assign -DCC.SINT.FNAME
  663.     ^assign -DCC.SINT.FSIZE
  664. }
  665.  
  666. # Checks to see if a file exists by trapping window output from a DCC SEND
  667. # to yourself.
  668. # Snak adaptation 1.4. Removed alias and made a built in function
  669.  
  670. #alias fileexists {
  671. #    @ EXISTS = 1
  672. #    ^on ^window "% *Cannot access*" {@ EXISTS = 0}
  673. #    ^on ^window * {}
  674. #    //dcc send $N $0
  675. #    ^on window - "% *Cannot access*"
  676. #    ^on window - *
  677. #    @ FUNCTION_RETURN = EXISTS
  678. #    ^assign -EXISTS
  679. #}
  680.  
  681. # args=<files>, returns sum of all file sizes, or 0 if a file's size isn't
  682. # saved in the buffer
  683. alias dcc.getpacksize {
  684.     @ PSIZE = 0
  685.     @ CT = 0
  686.     while ((!!word($CT $*))&&(PSIZE != [-1]))
  687.     {
  688.         @ FN = dcc.nameonly($word($CT $*))
  689.         if (DCC.FSIZES[$encode($tolower($FN))])
  690.         {
  691.             @ PSIZE = PSIZE + DCC.FSIZES[$encode($tolower($FN))]
  692.         } {@ PSIZE = [-1]}
  693.         @ CT = CT + 1
  694.     }
  695.     ^assign -CT
  696.     ^assign -FN
  697.     if (PSIZE == [-1]) {@ FUNCTION_RETURN = 0}
  698.     {@ FUNCTION_RETURN = PSIZE}
  699.     ^assign -PSIZE
  700. }
  701.  
  702. # /dcc.dolist <show filenames too?> <command to do list>
  703. alias dcc.dolist {
  704.     @ MAXV = 0
  705.     foreach DCCPACKS.FILES AA {^if (AA > MAXV) {@ MAXV = AA}}
  706.     @ AA = 0
  707.     while (AA <= MAXV)
  708.     {
  709.         if (DCCPACKS.FILES[$AA]) 
  710.         {
  711.             $1- #${AA} - $DCCPACKS.DESC[$AA]
  712.             @ FILS = DCCPACKS.FILES[$AA]
  713.             EVAL $1-    + [$#FILS file(s)] [$dcc.getpacksize($FILS) bytes] [downloaded $word(1 $DCCPACKS.STATS[$AA]) times]
  714.             if ([$0]) {$1- #${AA} - Files: $FILS}
  715.         }
  716.         @ AA = AA + 1
  717.     }
  718.     ^assign -FILS
  719.     ^assign -MAXV
  720.     if (DCC.NOTE) {$1- * Note: $DCC.NOTE}
  721. }
  722.  
  723. # Snak adaptation 1.4. returns number of packages offered
  724. alias dcc.havepacks {
  725.     @ FUNCTION_RETURN = 0
  726.     foreach DCCPACKS.FILES BsB {}
  727.     @ FUNCTION_RETURN = [$BsB]
  728.     ^assign -BsB
  729. }
  730.  
  731. # Queues a send for the timeout timer
  732. alias dcc.queuetimeout {@ DCC.TIMEOUTS[$encode($0)][$rand(99999)] = [$1 $2 $3]}
  733.  
  734. # Checks for DCC's that have timed out and runs queued DCC's
  735. on #^timer 22 * {
  736.     if (PP.SET.DCCTIMEOUT != [-1])
  737.     {
  738.         foreach DCC.TIMEOUTS AA {
  739.             EVAL ^foreach DCC.TIMEOUTS.$AA BB {
  740.                 if ([${time() - word(1 $DCC.TIMEOUTS[$AA][$BB])}] >= PP.SET.DCCTIMEOUT)
  741.                 {
  742.                     //^dcc close send $decode($AA) $word(2 $DCC.TIMEOUTS[$AA][$BB])
  743.                     //^dcc close send $decode($AA) ${W}/$word(0 $DCC.TIMEOUTS[$AA][$BB])
  744.                     if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}
  745.                     echo *** DCC SEND $word(2 $DCC.TIMEOUTS[$AA][$BB]) to $decode($AA) timed out
  746.                     //^notice $decode($AA) DCC SEND $word(2 $DCC.TIMEOUTS[$AA][$BB]) timed out
  747.                     ^assign -DCC.TIMEOUTS[$AA][$BB]
  748.                 }
  749.             }
  750.         }
  751.     }
  752.     if (PP.SET.DCCLIMIT != [-1])
  753.     {
  754.         while (dcc.gotqueue())
  755.         {
  756.             @ BB = 0
  757.             @ OLDESTQUEUE = 0
  758.             foreach DCC.SENDQUEUE AA {
  759.                 if ([${time() - AA}] > BB)
  760.                 {
  761.                     @ BB = time() - AA
  762.                     @ OLDESTQUEUE = AA
  763.                 }
  764.             }
  765.             echo *** Sending queued pack #$strip(# $word(2 $DCC.SENDQUEUE[$OLDESTQUEUE])) to $word(0 $DCC.SENDQUEUE[$OLDESTQUEUE])
  766.             ^alias echo {}
  767.             ^dcc.mcmd.send $DCC.SENDQUEUE[$OLDESTQUEUE]
  768.             ^alias -echo
  769.             ^assign -DCC.SENDQUEUE[$OLDESTQUEUE]
  770.         }
  771.         ^assign -OLDESTQUEUE
  772.     }
  773.     {
  774.         foreach DCC.SENDQUEUE AA {
  775.             echo *** Sending queued pack #$strip(# $word(2 $DCC.SENDQUEUE[$AA])) to $word(0 $DCC.SENDQUEUE[$AA])
  776.             ^alias echo {}
  777.             ^dcc.mcmd.send $DCC.SENDQUEUE[$AA]
  778.             ^alias -echo
  779.             ^assign -DCC.SENDQUEUE[$AA]
  780.         }
  781.     }
  782.     ^assign -BB
  783. }
  784.  
  785. # Returns true if files are queued and there are slots available
  786. alias dcc.gotqueue {
  787.     @ FUNCTION_RETURN = 0
  788.     foreach DCC.SENDQUEUE AB {^if (DCC.NSENDING < PP.SET.DCCLIMIT) {@ FUNCTION_RETURN = 1}}
  789.     ^assign -AB
  790. }
  791.  
  792. # Removes timeouts when sends are initiated
  793. on -window "% % DCC SEND connection to*established*" {
  794.     if (match(*[* $6)) {@ NIQ = left($index([ $6) $6)} {@ NIQ = [$6]}
  795.     foreach DCC.TIMEOUTS AA {^if (decode($AA) == NIQ) {^EVAL ^foreach DCC.TIMEOUTS.$AA BB {^assign -DCC.TIMEOUTS[$AA][$BB]}}}
  796.     ^assign -BB
  797.     ^assign -NIQ
  798. }
  799.  
  800. # Removes path from a filename
  801. alias dcc.nameonly {^if (match(*/* $0)) {@ FUNCTION_RETURN = mid(${rindex(/ $0)+1} 1000 $0)} {@ FUNCTION_RETURN = [$0]}}
  802.  
  803. # ----------------------------------------------------------------------------
  804. # User /msg command functions
  805. # ----------------------------------------------------------------------------
  806.  
  807. alias dcc.mcmd.version {
  808.     if (index(Y $PP.SET) == [-1])
  809.     {
  810.         //^notice $0 PurePak version $PPVERS DCC module
  811.         echo *** $0 [$strip( $1)] requested your version
  812.     }
  813. }
  814. alias dcc.mcmd.help {
  815.     //^notice $0 Available DCC server commands:
  816.     //^notice $0 HELP, LIST, SEND <#pack>, LSPACK <#pack>, VERSION
  817.     echo *** $0 [$strip( $1)] requested DCC server help
  818. }
  819. alias dcc.mcmd.list {
  820.     if (dcc.havepacks())
  821.     {
  822.         //^notice $0 Files available: Type /msg $N XDCC SEND #N to get pack #N
  823.         if (PP.SET.DCCLIMIT > 0) {//^notice $0 [${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]}
  824.         EVAL ^dcc.dolist 0 //^notice $0
  825.         echo *** $0 [$strip( $1)] requested a list of files offered
  826.     } {//^notice $0 No files offered}
  827. }
  828. # snak adaptation 1.5 use listitem
  829. alias dcc.mcmd.lspack {
  830.     if (DCCPACKS.FILES[$strip(# $2)])
  831.     {
  832.         //^notice $0 Files in pack #$strip(# $2)
  833.         @ AA = 0
  834.         while (listitem($AA $DCCPACKS.FILES[$strip(# $2)]))
  835.         {
  836.             //^notice $0   $dcc.nameonly($listitem($AA $DCCPACKS.FILES[$strip(# $2)])) [$dcc.getpacksize($listitem($AA $DCCPACKS.FILES[$strip(# $2)])) bytes]
  837.             @ AA = AA + 1
  838.         }
  839.         echo *** $0 [$strip( $1)] requested a list of files in pack #$strip(# $2)
  840.     } {//^notice $0 There is no pack #$strip(# $2)}
  841. }
  842. @ DCC.NSENDING = 0
  843.  
  844. # snak adaptation 1.5 use listitem and don't check for /
  845.  
  846. alias dcc.mcmd.send {
  847.  
  848.     if (DCCPACKS.FILES[$strip(# $2)])
  849.     {
  850.         if ((DCC.NSENDING >= PP.SET.DCCLIMIT)&&(PP.SET.DCCLIMIT != [-1]))
  851.         {
  852.             if (PP.SET.DCCQUEUEING == [ON])
  853.             {
  854.                 @ ALREADY = 0
  855.                 foreach DCC.SENDQUEUE AA {
  856.                     if ((word(0 $DCC.SENDQUEUE[$AA]) == [$0])&&(word(2 $DCC.SENDQUEUE[$AA]) == [$2]))
  857.                     {
  858.                         //^notice $0 You already have a request for pack #$strip(# $2) queued
  859.                         @ ALREADY = 1
  860.                     }
  861.                 }
  862.                 if (!ALREADY)
  863.                 {
  864.                     @ DCC.SENDQUEUE[$time()] = [$*]
  865.                     echo *** DCC SEND request for pack #$strip(# $2) to $0 queued: no more slots available
  866.                     //^notice $0 No more DCC slots available: your request has been queued
  867.                 }
  868.                 ^assign -ALREADY
  869.             }
  870.             {
  871.                 //^notice $0 No more DCC slots available
  872.                 echo *** DCC SEND request for pack #$strip(# $2) to $0 denied: no more slots available
  873.             }
  874.         }
  875.         {
  876.             @ PACKNUM = strip(# $2)
  877.             //^notice $0 Sending you pack #$PACKNUM \(you will need $dcc.getpacksize($DCCPACKS.FILES[$PACKNUM]) bytes\)
  878.             //^notice $0 Type /dcc get $N <file> for each request received
  879.             @ CTR = 0
  880.             @ AA = word(1 $DCCPACKS.STATS[$PACKNUM])
  881.             @ DCCPACKS.STATS[$PACKNUM] = [$word(0 $DCCPACKS.STATS[$PACKNUM]) ${AA+1}]
  882.             while (listitem($CTR $DCCPACKS.FILES[$PACKNUM]))
  883.             {
  884.                 @ AA = listitem($CTR $DCCPACKS.FILES[$PACKNUM])
  885. #                {
  886. #                    //^dcc close send $0 $word(0 $DCCPACKS.STATS[$PACKNUM])/$AA
  887. #                    //^dcc send $0 $word(0 $DCCPACKS.STATS[$PACKNUM])/$AA
  888. #                    @ SF = [$word(0 $DCCPACKS.STATS[$PACKNUM])/$AA]
  889. #                }
  890. #                {
  891.                     //^dcc close send $0 $AA
  892.                     //^dcc send $0 $AA
  893.                     @ SF = AA
  894. #                }
  895.                 if (PP.SET.DCCTIMEOUT > 0) {^dcc.queuetimeout $0 $dcc.nameonly($AA) $time() $SF}
  896.                 @ DCC.NSENDING = DCC.NSENDING + 1
  897.                 if ((PP.SET.DCCLIMIT != [-1])&&(DCC.NSENDING > PP.SET.DCCLIMIT)) {@ DCC.NSENDING = PP.SET.DCCLIMIT}
  898.                 @ CTR = CTR + 1
  899.             }
  900.             ^assign -SF
  901.             ^assign -CTR
  902.             echo *** DCC pack #$PACKNUM sent to $0 [$strip( $1)]
  903.             ^assign -PACKNUM
  904.         }
  905.     } {//^notice $0 There is no pack #$strip(# $2)}
  906. }
  907. on -window "% % DCC SEND:% *completed*" {^if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}}
  908. on -window "% % DCC SEND:% *lost*" {^if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}}
  909.  
  910. # ----------------------------------------------------------------------------
  911.  
  912. EVAL ^if (!PP.SET.NOSTARTUP) {/echo -- PurePak DCC server module loaded}
  913.